package monitor

import (
	"fmt"
	"time"

	"gitee.com/rw555/fdsmastergo/pkg/logger"
	"gitee.com/rw555/fdsmastergo/pkg/state"
	"go.uber.org/zap"
)

func (m *Monitor) StartAutoMode() error {
	logger.OperationInfo("启动自动模式", zap.String("mode", state.ModeAuto.String()))
	currentMode := m.mode
	if currentMode.HasMode(state.ModeForceHeat) || currentMode.HasMode(state.ModeForcePump) {
		err := fmt.Errorf("无法启动自动模式：当前处于强制模式 %v", currentMode)
		logger.OperationError(err.Error())
		return err
	}

	if err := m.device.OpenHeater1(); err != nil {
		err := fmt.Errorf("开启主加热器失败: %w", err)
		logger.OperationError(err.Error())
		return err
	}
	if err := m.device.OpenHeater2(); err != nil {
		err := fmt.Errorf("开启副加热器失败: %w", err)
		logger.OperationError(err.Error())
		return err
	}

	if err := m.device.ClosePump(); err != nil {
		err := fmt.Errorf("关闭泵失败: %w", err)
		logger.OperationError(err.Error())
		return err
	}
	m.power = 0
	m.device.SetPumpPower(m.power)

	m.mode = state.ModeAuto

	// 记录自动模式开始时间
	m.currentWorkingMinutes = 0
	m.autoModeStartTime = time.Now()
	m.autoModeStopTime = time.Now()
	m.lastDbUpdateTime = time.Now()

	logger.OperationInfo("自动模式已启动", zap.String("开始时间", m.autoModeStartTime.Format("2006-01-02 15:04:05")))
	return nil
}

func (m *Monitor) StopAutoMode() error {
	currentMode := m.mode
	if !currentMode.HasMode(state.ModeAuto) {
		err := fmt.Errorf("当前未处于自动模式")
		logger.OperationError(err.Error())
		return err
	}

	// 立即关闭加热器
	if err := m.device.CloseHeater1(); err != nil {
		err := fmt.Errorf("关闭主加热器失败: %w", err)
		logger.OperationError(err.Error())
		return err
	}
	if err := m.device.CloseHeater2(); err != nil {
		err := fmt.Errorf("关闭副加热器失败: %w", err)
		logger.OperationError(err.Error())
		return err
	}

	// 设置为退出中状态
	m.mode = state.ModeExitingAuto
	logger.OperationInfo("正在退出自动模式，等待泵停止...")

	openPump := int(m.systemConfig["monitor.temp_threshold.open_pump"].(float64))
	if m.currentTemp > openPump {
		m.device.OpenPump()
		m.configMutex.RLock()
		m.power = 100
		m.configMutex.RUnlock()
		m.device.SetPumpPower(m.power)

		// 延时关泵，单次定时器
		cleanupTime := int(m.systemConfig["monitor.auto_cleanup_time"].(float64))
		time.AfterFunc(time.Duration(cleanupTime)*time.Second, func() {
			m.cmdChan <- Command{
				Type: CommandTypeEvent,
				Data: EventCommandData{
					EventName: EventNameDelayClosePump,
				},
			}
		})
	} else {
		// 延时关泵，单次定时器
		time.AfterFunc(2*time.Second, func() {
			m.cmdChan <- Command{
				Type: CommandTypeEvent,
				Data: EventCommandData{
					EventName: EventNameDelayClosePump,
				},
			}
		})
	}

	m.autoModeStopTime = time.Now()
	minDuration := int(m.systemConfig["monitor.automode_min_duration"].(float64))
	if m.autoModeStopTime.Sub(m.autoModeStartTime).Minutes() >= float64(minDuration) &&
		m.autoModeStopTime.Sub(m.lastDbUpdateTime).Seconds() >= float64(5) {
		err := m.saveAutoModeSession(m.autoModeStartTime, m.autoModeStopTime)
		if err != nil {
			logger.SystemError("保存自动模式记录失败", zap.Error(err))
		}
	}
	m.currentWorkingMinutes = 0
	m.autoModeStopTime = time.Time{}
	m.autoModeStartTime = time.Time{}
	m.lastDbUpdateTime = time.Time{}

	return nil
}

func (m *Monitor) StartForceHeat() error {
	currentMode := m.mode
	if currentMode.HasMode(state.ModeAuto) || currentMode.HasMode(state.ModeExitingAuto) {
		err := fmt.Errorf("无法启动强制加热模式：当前处于%v", currentMode)
		logger.OperationError(err.Error())
		return err
	}

	if err := m.device.OpenHeater1(); err != nil {
		err := fmt.Errorf("开启主加热器失败: %w", err)
		logger.OperationError(err.Error())
		return err
	}
	if err := m.device.OpenHeater2(); err != nil {
		m.device.CloseHeater1() // 回滚操作
		err := fmt.Errorf("开启副加热器失败: %w", err)
		logger.OperationError(err.Error())
		return err
	}

	m.mode = (currentMode | state.ModeForceHeat)
	logger.OperationInfo("强制加热模式已启动")
	return nil
}

func (m *Monitor) StopForceHeat() error {
	currentMode := m.mode
	if !currentMode.HasMode(state.ModeForceHeat) {
		err := fmt.Errorf("当前未处于强制加热模式")
		logger.OperationError(err.Error())
		return err
	}

	// 关闭加热器
	if err := m.device.CloseHeater1(); err != nil {
		err := fmt.Errorf("关闭主加热器失败: %w", err)
		logger.OperationError(err.Error())
		return err
	}
	if err := m.device.CloseHeater2(); err != nil {
		err := fmt.Errorf("关闭副加热器失败: %w", err)
		logger.OperationError(err.Error())
		return err
	}

	m.mode = (currentMode &^ state.ModeForceHeat)
	logger.OperationInfo("强制加热模式已停止")
	return nil
}

func (m *Monitor) StartForcePump() error {
	currentMode := m.mode
	if currentMode.HasMode(state.ModeAuto) || currentMode.HasMode(state.ModeExitingAuto) {
		err := fmt.Errorf("无法启动强制泵模式：当前处于%v", currentMode)
		logger.OperationError(err.Error())
		return err
	}

	// 开启泵
	if err := m.device.OpenPump(); err != nil {
		err := fmt.Errorf("开启泵失败: %w", err)
		logger.OperationError(err.Error())
		return err
	}

	// 设置默认功率
	m.configMutex.RLock()
	m.power = int(m.systemConfig["monitor.power_adjust.duty_default"].(float64))
	m.configMutex.RUnlock()

	if err := m.device.SetPumpPower(m.power); err != nil {
		m.device.ClosePump() // 回滚操作
		err := fmt.Errorf("设置泵功率失败: %w", err)
		logger.OperationError(err.Error())
		return err
	}

	m.mode = (currentMode | state.ModeForcePump)
	logger.OperationInfo("强制泵模式已启动", zap.Int("默认功率", m.power))
	return nil
}

func (m *Monitor) StopForcePump() error {
	currentMode := m.mode
	if !currentMode.HasMode(state.ModeForcePump) {
		err := fmt.Errorf("当前未处于强制泵模式")
		logger.OperationError(err.Error())
		return err
	}

	// 关闭泵
	if err := m.device.ClosePump(); err != nil {
		err := fmt.Errorf("关闭泵失败: %w", err)
		logger.OperationError(err.Error())
		return err
	}

	// 设置默认功率
	m.configMutex.RLock()
	m.power = 0
	m.configMutex.RUnlock()

	if err := m.device.SetPumpPower(m.power); err != nil {
		err := fmt.Errorf("设置泵功率失败: %w", err)
		logger.OperationError(err.Error())
		return err
	}

	m.mode = (currentMode &^ state.ModeForcePump)
	logger.OperationInfo("强制泵模式已停止")
	return nil
}
